home *** CD-ROM | disk | FTP | other *** search
/ SPACE 1 / SPACE - Library 1 - Volume 1.iso / utilitys / 88 / ugbase / dbase2.c < prev    next >
Encoding:
C/C++ Source or Header  |  1987-09-03  |  38.5 KB  |  1,317 lines
  1.  
  2.  
  3. /************************************************************************/
  4.  
  5. /*                                                                      */
  6.  
  7. /*         This is a program to keep track of STar members              */
  8.  
  9. /*         and their equipment.                                         */
  10.  
  11. /*                                                                      */
  12.  
  13. /************************************************************************/
  14.  
  15. /* Include our necessary files...  */
  16.  
  17.  
  18.  
  19. #include "dbase.h"
  20.  
  21. #include <osbind.h>
  22.  
  23. #include <stdio.h>
  24.  
  25. #include <gemdefs.h>
  26.  
  27.  
  28.  
  29. /* The usual required GEM arrays   */
  30.  
  31.  
  32.  
  33. int work_in[11],
  34.  
  35.     work_out[57],
  36.  
  37.     pxyarray[10],
  38.  
  39.     contrl[12],
  40.  
  41.     intin[128],
  42.  
  43.     ptsin[128],
  44.  
  45.     intout[128],
  46.  
  47.     ptsout[128];
  48.  
  49.  
  50.  
  51. /*  Global variables  */
  52.  
  53.  
  54.  
  55. int handle,dum,event, rnum,rez,srchit,selprt;
  56.  
  57. int dial_x,vdial_x,tdial_x,rdial_x; /*  Dialog x coordinate     */
  58.  
  59.     dial_y,vdial_y,tdial_y,rdial_y; /*  Dialog y coordinate     */
  60.  
  61.     dial_w,vdial_w,tdial_w,rdial_w; /*  Dialog width            */
  62.  
  63.     dial_h;vdial_h,tdial_h,rdial_h; /*  Dialog height           */
  64.  
  65.  
  66.  
  67. int msgbuf[8];  /*   Event message buffer   */
  68.  
  69.  
  70.  
  71. char pathname[50],filename[13];   /*   file name buffers   */
  72.  
  73.  
  74.  
  75. /*   Structure to hold an object's description    */
  76.  
  77.  
  78.  
  79. typedef struct object
  80.  
  81. {
  82.  
  83.    int          ob_next;
  84.  
  85.    int          ob_head;
  86.  
  87.    int          ob_tail;
  88.  
  89.    unsigned int ob_type;
  90.  
  91.    unsigned int ob_flags;
  92.  
  93.    unsigned int ob_state;
  94.  
  95.    char         *ob_spec;
  96.  
  97.    int          ob_x;
  98.  
  99.    int          ob_y;
  100.  
  101.    int          ob_w;
  102.  
  103.    int          ob_h;
  104.  
  105. } OBJECT;
  106.  
  107.  
  108.  
  109. OBJECT *tree_addr,*menu_addr,
  110.  
  111.        *prnt_addr,*srch_addr,  /*  Pointers to our object structures */
  112.  
  113.        *kudo_addr;
  114.  
  115.  
  116.  
  117. FILE *prt;   /*  pointer to printer ID   */
  118.  
  119.  
  120.  
  121. /*  Structure to hold object text information    */
  122.  
  123.  
  124.  
  125. typedef struct text_edinfo
  126.  
  127. {
  128.  
  129.    char *te_ptext;
  130.  
  131.    char *te_ptmplt;
  132.  
  133.    char *te_pvalid;
  134.  
  135.    int  te_font;
  136.  
  137.    int  te_junk1;
  138.  
  139.    int  te_color;
  140.  
  141.    int  te_junk2;
  142.  
  143.    int  te_thickness;
  144.  
  145.    int  te_txtlen;
  146.  
  147.    int  te_tmplen;
  148.  
  149. } TEDINFO;
  150.  
  151.  
  152.  
  153. /*   Structure to hold all data base information   */
  154.  
  155.  
  156.  
  157. struct RECORD
  158.  
  159. {
  160.  
  161.     char lname[16];    /*  Last name       */   
  162.  
  163.         char fname[21];    /*  First name      */
  164.  
  165.     char addr[31];     /*  Address         */
  166.  
  167.     char city[21];     /*  City            */
  168.  
  169.     char state[3];     /*  State           */
  170.  
  171.     char zip[6];       /*  Zip code        */
  172.  
  173.     char phone[15];    /*  Phone #         */
  174.  
  175.         char status[11];   /*  Dues Status     */
  176.  
  177.     char comp[7];      /*  Computer type   */
  178.  
  179.     char drive[12];    /*  Drive(s) type   */
  180.  
  181.     char modem[16];    /*  Modem type      */   
  182.  
  183.         char prnt[16];     /*  Printer type    */
  184.  
  185.     char other[26];    /*  Other stuff     */
  186.  
  187.     char intr1[26];    /*  Interests pt. 1 */
  188.  
  189.     char intr2[26];    /*  Interests pt. 2 */
  190.  
  191. };
  192.  
  193.  
  194.  
  195. #define NUM_REC 200
  196.  
  197. #define TRUE 1
  198.  
  199. #define FALSE 0
  200.  
  201.  
  202.  
  203. int srch_flag[NUM_REC];
  204.  
  205. struct RECORD *dbase;
  206.  
  207. char *find_str();     
  208.  
  209.  
  210.  
  211. /*  All strings for our alert boxes....   */
  212.  
  213.  
  214.  
  215. static char sure[] =  "[2][|Are you sure you want to quit?|][QUIT|CANCEL]";
  216.  
  217. static char cantopen[]="[1][| Can't open that file! |][SORRY]";
  218.  
  219. static char wrngfrmt[]="[1][| This file is not in| UGbase format!|][Crud!!]";
  220.  
  221. static char delete[]="[2][|  Are you sure you want|  to delete this entry?|][DELETE|CANCEL]";
  222.  
  223. static char clear[]="[2][CAUTION!|This will erase |any data in memory|Are you sure?][OK|CANCEL]";
  224.  
  225. static char full[]="[1][|Data base is full! you can't|add any more records!|][NUTS!!]";
  226.  
  227. static char empty[]="[1][|There are no records to delete!|][NUTS!!]";
  228.  
  229. static char no_mem[]="[1][|Can't allocate memory for file!|][ OK ]";
  230.  
  231. static char nonethere[]="[1][|No matching records found!|][SORRY!]";
  232.  
  233.  
  234.  
  235. /*  Printer codes for various functions. For Gemini 10X & compats only.
  236.  
  237.     Change these to fit your printer                                      */
  238.  
  239.  
  240.  
  241. int ffeed=12;
  242.  
  243. char condensed[3]={27,15,0};
  244.  
  245. char expanded[4]={18,27,14,0};
  246.  
  247. char nrml[3]={27,80,0};
  248.  
  249.  
  250.  
  251. /*  Miscellaneous strings.....    */
  252.  
  253.  
  254.  
  255. char sepr2[132],title[30];
  256.  
  257.  
  258.  
  259. /*************************************************************************/
  260.  
  261.  
  262.  
  263. /*  This is the main routine   */
  264.  
  265.  
  266.  
  267. main ()
  268.  
  269. {
  270.  
  271.  
  272.  
  273.    appl_init ();
  274.  
  275.    
  276.  
  277.    rez=Getrez();
  278.  
  279.    if(rez)   /*  Check for high or med. rez and continue if OK   */
  280.  
  281.    {
  282.  
  283.  
  284.  
  285. /* allocate memory */
  286.  
  287.  
  288.  
  289. if ((dbase = (struct RECORD *)
  290.  
  291.   Malloc( (long)(sizeof(struct RECORD) * NUM_REC)) 
  292.  
  293.    ) == 0)
  294.  
  295.             form_alert(1,no_mem); 
  296.  
  297.  
  298.  
  299.      open_vwork ();
  300.  
  301.  
  302.  
  303.      do_kudos();              /*  List credits...    */
  304.  
  305.      menu_bar (menu_addr,1);  /*  Install our menu   */
  306.  
  307.  
  308.  
  309.      do_menu ();              /*  Monitors menu      */
  310.  
  311.      menu_bar(menu_addr,0);   /*  Turn off our menu  */
  312.  
  313.      graf_mouse(ARROW,&dum);  /*  Fix mouse pointer  */
  314.  
  315.      v_clsvwk (handle);       /*  Outta here!        */
  316.  
  317.    }
  318.  
  319.    else form_alert(1,"[1][|UGBase only works in|medium or high rez!|][@%&!*^%]");
  320.  
  321.  
  322.  
  323.    appl_exit ();
  324.  
  325. }
  326.  
  327.  
  328.  
  329. /*************************************************************************/
  330.  
  331.  
  332.  
  333. open_vwork ()
  334.  
  335. {
  336.  
  337.    int i;
  338.  
  339.  
  340.  
  341. /*  Get handle of work station and open it up!    */
  342.  
  343.  
  344.  
  345.    handle = graf_handle (&dum,&dum,&dum,&dum);
  346.  
  347.    for (i=0;i<10;work_in[i++]=1);
  348.  
  349.    work_in[10]=2;
  350.  
  351.    v_opnvwk (work_in,&handle,work_out);
  352.  
  353.  
  354.  
  355. /* Fills our separator string with dashes   */
  356.  
  357.  
  358.  
  359.    for(i=0;i<132;sepr2[i++]='-');
  360.  
  361.  
  362.  
  363. /*  Load in Resource file and assign addresses to each object    */
  364.  
  365.  
  366.  
  367.    rsrc_load("dbase.rsc");
  368.  
  369.    rsrc_gaddr (R_TREE,DBMENU,&menu_addr);
  370.  
  371.    rsrc_gaddr (R_TREE,DBASE,&tree_addr);
  372.  
  373.    rsrc_gaddr (R_TREE,OUTPUT,&prnt_addr);
  374.  
  375.    rsrc_gaddr (R_TREE,KUDOS,&kudo_addr);
  376.  
  377.    rsrc_gaddr (R_TREE,DBSEARCH,&srch_addr);
  378.  
  379.  
  380.  
  381.    rnum=0;         /*  Sets our record counter to zero   */
  382.  
  383.  
  384.  
  385.    graf_mouse(POINT_HAND,&dum);  /* turns mouse into pointing hand  */
  386.  
  387.  
  388.  
  389. /*  Finds offsets to two data boxes in data base dialog box  */
  390.  
  391. /*  This will make updating the box smoother (hopefully!)    */
  392.  
  393.  
  394.  
  395.    vdial_w=528;
  396.  
  397.    tdial_w=528;
  398.  
  399.    vdial_h=56 * Getrez();;
  400.  
  401.    tdial_h=40 * Getrez();;
  402.  
  403.    rdial_w=176;
  404.  
  405.    rdial_h=40 * Getrez();
  406.  
  407.  
  408.  
  409. }
  410.  
  411.  
  412.  
  413. /*************************************************************************/
  414.  
  415.  
  416.  
  417. do_menu()
  418.  
  419. {
  420.  
  421. int check,quitflag,i,type;
  422.  
  423.  
  424.  
  425.    do
  426.  
  427.    {
  428.  
  429.         quitflag=0;       /* Flag for telling when to exit this routine   */
  430.  
  431.  
  432.  
  433. /*  This monitors menu and lets us know when user has selected an item  */
  434.  
  435.  
  436.  
  437.         event = evnt_multi (MU_MESAG,1,1,1,0,0,0,0,0,0,0,0,0,0,msgbuf,
  438.  
  439.                             0,0,&dum,&dum,&dum,&dum,&dum,&dum);
  440.  
  441.          
  442.  
  443.         if(event==MU_MESAG)
  444.  
  445.         {
  446.  
  447.  
  448.  
  449. /*  Find out what user selected    */
  450.  
  451.  
  452.  
  453.             switch (msgbuf[0])
  454.  
  455.             {
  456.  
  457.                  case MN_SELECTED:
  458.  
  459.             
  460.  
  461.                      switch (msgbuf[3])
  462.  
  463.                      {
  464.  
  465.                          case DESK:  /* it was credits option, so do credits */
  466.  
  467.  
  468.  
  469.                           if(msgbuf[4]==CREDITS)
  470.  
  471.                             do_kudos();
  472.  
  473.                             menu_tnormal(menu_addr,DESK,1); /* fix menu item */
  474.  
  475.  
  476.  
  477.                         break;
  478.  
  479.                         
  480.  
  481.                         case NFILE:  /*  File selected, now which option in
  482.  
  483.                                                 file was selected?          */
  484.  
  485.                 switch (msgbuf[4])
  486.  
  487.                           {
  488.  
  489.                   case NEW: /*  Clear out data base & start fresh */
  490.  
  491.                                 check=form_alert(2,clear);
  492.  
  493.                                 if(check==1)
  494.  
  495.                                 {
  496.  
  497.                                     for(i=0;i<=rnum;clear_dbase(i++));
  498.  
  499.                                       rnum=0;               
  500.  
  501.                                       srchit=FALSE;
  502.  
  503.                                       do_dialog(); 
  504.  
  505.                                 }
  506.  
  507.                                break;
  508.  
  509.  
  510.  
  511.                                case OPEN:  /*  Open a new file  */
  512.  
  513.                                  if(sel_file())
  514.  
  515.                                  {
  516.  
  517.                                    check=form_alert(2,clear);
  518.  
  519.                                    if(check==1)
  520.  
  521.                                    {
  522.  
  523.                                     for(i=0;i<NUM_REC;clear_dbase(i++));
  524.  
  525.                                     rnum=0;               
  526.  
  527.                                     if(read_file())
  528.  
  529.                                     {
  530.  
  531.                                        srchit=FALSE;
  532.  
  533.                                        do_dialog();
  534.  
  535.                                     }
  536.  
  537.                                    }
  538.  
  539.                                  }
  540.  
  541.                                break;
  542.  
  543.  
  544.  
  545.                                case SAVE:  /* Save file with current name  */
  546.  
  547.                                  write_file();
  548.  
  549.                                break;
  550.  
  551.  
  552.  
  553.                                case SAVEAS:  /*  Gets new name to save under */
  554.  
  555.                                  if(sel_file())
  556.  
  557.                                  {
  558.  
  559.                                     if(make_file())   
  560.  
  561.                                     write_file();
  562.  
  563.                                   }
  564.  
  565.                    break;
  566.  
  567.                        
  568.  
  569.                                case ERASE:  /*  Erases data without entering
  570.  
  571.                         dialog box                 */
  572.  
  573.                                  check=form_alert(2,clear);
  574.  
  575.                                  if(check==1)
  576.  
  577.                                  {
  578.  
  579.                                     for(i=0;i<=rnum;i++)
  580.  
  581.                                       clear_dbase(i);
  582.  
  583.                                     rnum=0;               
  584.  
  585.                                  }
  586.  
  587.                                break;
  588.  
  589.                                
  590.  
  591.                                case EDIT: /* opens box for editing   */
  592.  
  593.                                  srchit=FALSE;
  594.  
  595.                                  do_dialog();
  596.  
  597.                                break;
  598.  
  599.                                                  
  600.  
  601.                                case QUIT:  /* Exits program   */
  602.  
  603.                                  check=form_alert(2,sure);
  604.  
  605.                                  if(check==1) quitflag=1;
  606.  
  607.                                  else quitflag=0;
  608.  
  609.                                break;
  610.  
  611.  
  612.  
  613.                          }
  614.  
  615.                          menu_tnormal(menu_addr,NFILE,1); /* fix menu item */
  616.  
  617.                         break;
  618.  
  619.                          
  620.  
  621.                         case OPTIONS:  /* Options chose, find which item  */
  622.  
  623.  
  624.  
  625.                             switch (msgbuf[4])
  626.  
  627.                           {
  628.  
  629.                              case PRINT:  /* Wants to print, eh?   */
  630.  
  631.                                  print_data();
  632.  
  633.                              break;
  634.  
  635.                                     
  636.  
  637.                              case SORT:  /* Sorts data by last name  */
  638.  
  639.                                do_sort();
  640.  
  641.                              break;
  642.  
  643.  
  644.  
  645.                              case SEARCH:
  646.  
  647.                                do_search();
  648.  
  649.                              break;
  650.  
  651.                               
  652.  
  653.                           }
  654.  
  655.                           menu_tnormal(menu_addr,OPTIONS,1); /* you know  */
  656.  
  657.                         break;            
  658.  
  659.                      } 
  660.  
  661.     
  662.  
  663.                  break;             
  664.  
  665.             }
  666.  
  667.         }
  668.  
  669.    }
  670.  
  671.    while (quitflag==0);
  672.  
  673.    
  674.  
  675. }
  676.  
  677.  
  678.  
  679. /*************************************************************************/
  680.  
  681.    
  682.  
  683. do_dialog () 
  684.  
  685. {
  686.  
  687. int ent=0,next,choice,check;
  688.  
  689.  
  690.  
  691. if(srchit)
  692.  
  693.   set_obj(tree_addr,ADD,0x0008);
  694.  
  695. else clear_obj(tree_addr,ADD,0xFFF7);
  696.  
  697.  
  698.  
  699. /* gets all good info on dialog box and draws growing box   */
  700.  
  701.  
  702.  
  703.       form_center (tree_addr,&dial_x,&dial_y,&dial_w,&dial_h);
  704.  
  705.       objc_offset(tree_addr,VITALS,&vdial_x,&vdial_y);
  706.  
  707.       objc_offset(tree_addr,TOYS,&tdial_x,&tdial_y);
  708.  
  709.       form_dial (FMD_START,0,0,10,10,dial_x,dial_y,dial_w,dial_h);
  710.  
  711.       form_dial (FMD_GROW,0,0,10,10,dial_x,dial_y,dial_w,dial_h);  
  712.  
  713.       objc_draw(tree_addr,DBASE,2,dial_x,dial_y,dial_w,dial_h);
  714.  
  715.  
  716.  
  717. /* This loop monitors box and acts on user input     */
  718.  
  719.  
  720.  
  721.        ent=do_start();
  722.  
  723.        do {
  724.  
  725.          get_data(ent);  /*  Gets current record for display  */
  726.  
  727.          choice = form_do (tree_addr,LNAME); /* Monitor box   */
  728.  
  729.  
  730.  
  731.          switch(choice)
  732.  
  733.          {
  734.  
  735.  
  736.  
  737.             case NEXT:  /*  Gets next record in file   */
  738.  
  739.               next=do_next(ent);
  740.  
  741.               if(next>=0)
  742.  
  743.                 ent=next;
  744.  
  745.             break;
  746.  
  747.  
  748.  
  749.             case PREV:  /*  Gets previous record in file */
  750.  
  751.               next=do_prev(ent);
  752.  
  753.               if(next>=0)
  754.  
  755.                 ent=next;
  756.  
  757.             break;
  758.  
  759.  
  760.  
  761.             case START:  /*  Goes to start of file   */
  762.  
  763.               ent=do_start();
  764.  
  765.             break;
  766.  
  767.  
  768.  
  769.             case END:  /*  Goes to end of file      */
  770.  
  771.               ent=do_end();
  772.  
  773.             break;
  774.  
  775.  
  776.  
  777.             case ADD: /*  Adds record to end of file  */
  778.  
  779.               if(srchit==FALSE)
  780.  
  781.               {
  782.  
  783.                   save_data(ent++);
  784.  
  785.                   rnum=rnum+1;
  786.  
  787.                   if(rnum>NUM_REC)
  788.  
  789.                   {  
  790.  
  791.                       rnum=NUM_REC;
  792.  
  793.                       form_alert(1,full);
  794.  
  795.                       ent=rnum;
  796.  
  797.                   }
  798.  
  799.               }
  800.  
  801.             break;
  802.  
  803.  
  804.  
  805.             case DELETE:  /* Deletes record from file  */
  806.  
  807.               if(rnum>0)
  808.  
  809.               {
  810.  
  811.                  check=form_alert(2,delete);
  812.  
  813.                  if(check==1)
  814.  
  815.                  {
  816.  
  817.                       del_rec(ent--);
  818.  
  819.                       if(ent<0) ent=0;
  820.  
  821.                       rnum--;
  822.  
  823.                       if(rnum<0) rnum=0;
  824.  
  825.                  }
  826.  
  827.               }
  828.  
  829.               else form_alert(1,empty);
  830.  
  831.             break;
  832.  
  833.         
  834.  
  835.             case UPDATE:  /* Updates current record   */
  836.  
  837.               save_data(ent);
  838.  
  839.             break;
  840.  
  841.          }
  842.  
  843.        }     
  844.  
  845.        while (choice != EXIT);
  846.  
  847.  
  848.  
  849. /*  Close box and go back to menu   */
  850.  
  851.  
  852.  
  853.       form_dial (FMD_SHRINK,0,0,10,10,dial_x,dial_y,dial_w,dial_h);
  854.  
  855.       form_dial (FMD_FINISH,0,0,10,10,dial_x,dial_y,dial_w,dial_h);
  856.  
  857.  
  858.  
  859. }
  860.  
  861.  
  862.  
  863. /*************************************************************************/
  864.  
  865.  
  866.  
  867. /*  This routine takes the data from the dialog box and saves it into its
  868.  
  869.     respective place in the file                    */
  870.  
  871.  
  872.  
  873. save_data(ent)
  874.  
  875. int ent;
  876.  
  877. {
  878.  
  879.  OBJECT *tree;
  880.  
  881.  
  882.  
  883.     find_str(tree_addr,LNAME,(dbase +  ent)->lname);
  884.  
  885.     find_str(tree_addr,FNAME,(dbase + ent)->fname);
  886.  
  887.     find_str(tree_addr,ADDR,(dbase + ent)->addr);
  888.  
  889.     find_str(tree_addr,CITY,(dbase + ent)->city);
  890.  
  891.     find_str(tree_addr,STATE,(dbase + ent)->state);
  892.  
  893.     find_str(tree_addr,ZIP,(dbase + ent)->zip);
  894.  
  895.     find_str(tree_addr,PHONE,(dbase + ent)->phone);
  896.  
  897.     find_str(tree_addr,STATUS,(dbase + ent)->status);
  898.  
  899.     find_str(tree_addr,COMP,(dbase + ent)->comp);
  900.  
  901.     find_str(tree_addr,DRIVE,(dbase + ent)->drive);
  902.  
  903.     find_str(tree_addr,MODEM,(dbase + ent)->modem);
  904.  
  905.     find_str(tree_addr,PRNT,(dbase + ent)->prnt);
  906.  
  907.     find_str(tree_addr,OTHER,(dbase + ent)->other);
  908.  
  909.     find_str(tree_addr,INTR1,(dbase + ent)->intr1);
  910.  
  911.     find_str(tree_addr,INTR2,(dbase + ent)->intr2);
  912.  
  913.  
  914.  
  915. }
  916.  
  917.  
  918.  
  919. /*************************************************************************/
  920.  
  921.  
  922.  
  923. /* Used by above routine to get each item and save it   */
  924.  
  925.  
  926.  
  927. char *find_str(tree,obj,string)
  928.  
  929. int obj;
  930.  
  931. char *string;
  932.  
  933. OBJECT *tree;
  934.  
  935. {
  936.  
  937.         char *temp;
  938.  
  939.     TEDINFO *ob_tedinfo;
  940.  
  941.     
  942.  
  943.         ob_tedinfo=(TEDINFO *)tree[obj].ob_spec;
  944.  
  945.         temp=ob_tedinfo->te_ptext;
  946.  
  947.         strcpy(string,temp);
  948.  
  949. }
  950.  
  951.  
  952.  
  953. /*************************************************************************/
  954.  
  955.  
  956.  
  957. /*  Routine to find length of a given string   */
  958.  
  959.  
  960.  
  961. find_len(tree,obj)
  962.  
  963. int obj;
  964.  
  965. OBJECT *tree;
  966.  
  967. {
  968.  
  969.         int temp;
  970.  
  971.     TEDINFO *ob_tedinfo;
  972.  
  973.     
  974.  
  975.         ob_tedinfo=(TEDINFO *)tree[obj].ob_spec;
  976.  
  977.         temp=ob_tedinfo->te_txtlen;
  978.  
  979.         printf("Length is %d characters.\n",temp);
  980.  
  981.         return(temp);
  982.  
  983. }
  984.  
  985.  
  986.  
  987. /*************************************************************************/
  988.  
  989.  
  990.  
  991. /* Reverse of find_str... writes each item back to dialog box   */
  992.  
  993.  
  994.  
  995. wrt_str(tree,objnum,string)
  996.  
  997. int objnum;
  998.  
  999. char *string;
  1000.  
  1001. OBJECT *tree;
  1002.  
  1003. {
  1004.  
  1005.     TEDINFO *ob_tedinfo;
  1006.  
  1007.     
  1008.  
  1009.     ob_tedinfo = (TEDINFO *)tree[objnum].ob_spec;
  1010.  
  1011.     ob_tedinfo->te_ptext=string;
  1012.  
  1013. }
  1014.  
  1015.  
  1016.  
  1017. /*************************************************************************/
  1018.  
  1019.  
  1020.  
  1021. /*  This routine gets a record from the file and places it in the dialog box */
  1022.  
  1023.  
  1024.  
  1025. get_data(ent)
  1026.  
  1027. int ent;
  1028.  
  1029.  
  1030.  
  1031. {
  1032.  
  1033. char recnumber[3];
  1034.  
  1035.  
  1036.  
  1037.    sprintf(recnumber,"%3d",ent+1);
  1038.  
  1039.    wrt_str(tree_addr,RECNUM,recnumber);
  1040.  
  1041.    wrt_str(tree_addr,LNAME,(dbase + ent)->lname);
  1042.  
  1043.    wrt_str(tree_addr,FNAME,(dbase + ent)->fname);
  1044.  
  1045.    wrt_str(tree_addr,ADDR,(dbase + ent)->addr);
  1046.  
  1047.    wrt_str(tree_addr,CITY,(dbase + ent)->city);
  1048.  
  1049.    wrt_str(tree_addr,STATE,(dbase + ent)->state);
  1050.  
  1051.    wrt_str(tree_addr,ZIP,(dbase + ent)->zip);
  1052.  
  1053.    wrt_str(tree_addr,PHONE,(dbase + ent)->phone);
  1054.  
  1055.    wrt_str(tree_addr,STATUS,(dbase + ent)->status);
  1056.  
  1057.    wrt_str(tree_addr,COMP,(dbase + ent)->comp);
  1058.  
  1059.    wrt_str(tree_addr,DRIVE,(dbase + ent)->drive);
  1060.  
  1061.    wrt_str(tree_addr,MODEM,(dbase + ent)->modem);
  1062.  
  1063.    wrt_str(tree_addr,PRNT,(dbase + ent)->prnt);
  1064.  
  1065.    wrt_str(tree_addr,OTHER,(dbase + ent)->other);
  1066.  
  1067.    wrt_str(tree_addr,INTR1,(dbase + ent)->intr1);
  1068.  
  1069.    wrt_str(tree_addr,INTR2,(dbase + ent)->intr2);
  1070.  
  1071.    objc_draw(tree_addr,VITALS,7,vdial_x,vdial_y,vdial_w,vdial_h);
  1072.  
  1073.    objc_draw(tree_addr,TOYS,7,tdial_x,tdial_y,tdial_w,tdial_h);
  1074.  
  1075. }
  1076.  
  1077.  
  1078.  
  1079. /*************************************************************************/
  1080.  
  1081.  
  1082.  
  1083. /*  Deletes a record and moves remaining records up to fill gap.    */
  1084.  
  1085.  
  1086.  
  1087. del_rec(num)
  1088.  
  1089. int num;
  1090.  
  1091. {
  1092.  
  1093.     int i;
  1094.  
  1095.     
  1096.  
  1097.     for(i=num;i<rnum;i++)
  1098.  
  1099.     {
  1100.  
  1101.         strcpy((dbase + i)->lname,(dbase + i + 1)->lname);
  1102.  
  1103.         strcpy((dbase + i)->fname,(dbase + i + 1)->fname);
  1104.  
  1105.         strcpy((dbase + i)->addr,(dbase + i + 1)->addr);
  1106.  
  1107.         strcpy((dbase + i)->city,(dbase + i + 1)->city);
  1108.  
  1109.         strcpy((dbase + i)->state,(dbase + i + 1)->state);
  1110.  
  1111.         strcpy((dbase + i)->zip,(dbase + i + 1)->zip);
  1112.  
  1113.         strcpy((dbase + i)->phone,(dbase + i + 1)->phone);
  1114.  
  1115.         strcpy((dbase + i)->status,(dbase + i + 1)->status);
  1116.  
  1117.         strcpy((dbase + i)->comp,(dbase + i + 1)->comp);
  1118.  
  1119.         strcpy((dbase + i)->drive,(dbase + i + 1)->drive);
  1120.  
  1121.         strcpy((dbase + i)->modem,(dbase + i + 1)->modem);
  1122.  
  1123.         strcpy((dbase + i)->prnt,(dbase + i + 1)->prnt);
  1124.  
  1125.         strcpy((dbase + i)->other,(dbase + i + 1)->other);
  1126.  
  1127.         strcpy((dbase + i)->intr1,(dbase + i + 1)->intr1);
  1128.  
  1129.         strcpy((dbase + i)->intr2,(dbase + i + 1)->intr2);
  1130.  
  1131.      }
  1132.  
  1133.       clear_dbase(i);
  1134.  
  1135. }
  1136.  
  1137.  
  1138.  
  1139. /*************************************************************************/
  1140.  
  1141.  
  1142.  
  1143. /*  Opens a file selector box and gets name and path of file to load   */
  1144.  
  1145.  
  1146.  
  1147. sel_file()
  1148.  
  1149. {
  1150.  
  1151.     int button;
  1152.  
  1153.     
  1154.  
  1155.         pathname[0]=Dgetdrv()+'A';
  1156.  
  1157.         strcpy(&pathname[1],":.\\*.*");
  1158.  
  1159.         fsel_input(pathname,filename,&button);
  1160.  
  1161.         strcpy(&pathname[strlen(pathname)-3],filename);
  1162.  
  1163.         if(button==1) return(1);
  1164.  
  1165.         else return(0);    
  1166.  
  1167. }
  1168.  
  1169.  
  1170.  
  1171. /*************************************************************************/
  1172.  
  1173.  
  1174.  
  1175. /*  Reads in file. If an error occurs, a flag is returned and alert box is
  1176.  
  1177.     shown. If all's OK, file is loaded and returns to menu         */
  1178.  
  1179. read_file()
  1180.  
  1181. {
  1182.  
  1183.        int i,fhand,magicnum;
  1184.  
  1185.        long reclen;
  1186.  
  1187.  
  1188.  
  1189.         fhand=Fopen(pathname,0);
  1190.  
  1191.         if(fhand>=0)
  1192.  
  1193.     {
  1194.  
  1195.                 Fread(fhand,2L,&magicnum);
  1196.  
  1197.                 if(magicnum!=0xBEAD & magicnum!=0xCAFE)
  1198.  
  1199.                 {
  1200.  
  1201.                     form_alert(1,wrngfrmt);
  1202.  
  1203.                     Fclose(fhand);
  1204.  
  1205.                     return(0); 
  1206.  
  1207.                 }
  1208.  
  1209.                 else {
  1210.  
  1211.                         if(magicnum==0xBEAD)
  1212.  
  1213.                            reclen=253L;
  1214.  
  1215.                         else reclen=sizeof (struct RECORD);
  1216.  
  1217.  
  1218.  
  1219.                  Fread(fhand,2L,&rnum);
  1220.  
  1221.                 for(i=0;i<=rnum;i++)
  1222.  
  1223.                         Fread(fhand,reclen,(dbase + i)->lname);
  1224.  
  1225.                         Fclose(fhand);
  1226.  
  1227.                         return(1); 
  1228.  
  1229.                 }  
  1230.  
  1231.          }
  1232.  
  1233.          else
  1234.  
  1235.          { 
  1236.  
  1237.             form_alert(1,cantopen);
  1238.  
  1239.             Fclose(fhand);
  1240.  
  1241.             return(0);
  1242.  
  1243.          }
  1244.  
  1245.  } 
  1246.  
  1247.  
  1248.  
  1249. /*************************************************************************/
  1250.  
  1251.  
  1252.  
  1253. /*  Writes info to specified file. If an error occurs, a flag is returned 
  1254.  
  1255.     and an alert box is printed.  */
  1256.  
  1257.  
  1258.  
  1259. write_file()
  1260.  
  1261. {
  1262.  
  1263.         int i,fhand,magicnum=0xCAFE;
  1264.  
  1265.  
  1266.  
  1267.     fhand=Fopen(pathname,1);
  1268.  
  1269.         if(fhand>=0)
  1270.  
  1271.     {
  1272.  
  1273.                 Fwrite(fhand,2L,&magicnum);
  1274.  
  1275.         Fwrite(fhand,2L,&rnum);
  1276.  
  1277.         for(i=0;i<=rnum;i++)
  1278.  
  1279.        Fwrite(fhand,(long)sizeof(struct RECORD),(dbase + i)->lname);
  1280.  
  1281.     }
  1282.  
  1283.     else form_alert(1,cantopen);
  1284.  
  1285.     Fclose(fhand);
  1286.  
  1287. }
  1288.  
  1289.  
  1290.  
  1291. /*************************************************************************/
  1292.  
  1293.  
  1294.  
  1295. /*  Creates a file for first time saves. Uses filename and path found in
  1296.  
  1297.     Sel_file() .  */
  1298.  
  1299.  
  1300.  
  1301. make_file()
  1302.  
  1303. {
  1304.  
  1305.     int fhand;
  1306.  
  1307.     fhand=Fcreate(pathname,0);
  1308.  
  1309.         if(fhand<0)
  1310.  
  1311.         {
  1312.  
  1313.            form_alert(1,cantopen);
  1314.  
  1315.            Fclose(fhand);
  1316.  
  1317.            return(0);
  1318.  
  1319.         }
  1320.  
  1321.         else
  1322.  
  1323.         { 
  1324.  
  1325.       Fclose(fhand);
  1326.  
  1327.         return(1);
  1328.  
  1329.         }                           
  1330.  
  1331. }   
  1332.  
  1333.     
  1334.  
  1335. /*************************************************************************/
  1336.  
  1337.  
  1338.  
  1339. /* Used by delete_rec()and file clearing options, this routine clears a 
  1340.  
  1341.    record from memory.    */
  1342.  
  1343.  
  1344.  
  1345. clear_dbase(i)
  1346.  
  1347. int i;
  1348.  
  1349. {
  1350.  
  1351.    int ctr;
  1352.  
  1353.    for(ctr=0; ctr < sizeof(struct RECORD); ctr++)
  1354.  
  1355.      (dbase + i)->lname[ctr]='\0'; 
  1356.  
  1357.  
  1358.  
  1359. }
  1360.  
  1361.  
  1362.  
  1363. /*************************************************************************/
  1364.  
  1365.  
  1366.  
  1367. /* Sets bit(s) in ob_state of object in specified tree  */
  1368.  
  1369.  
  1370.  
  1371. set_obj(tree,which,mask)
  1372.  
  1373. OBJECT *tree;
  1374.  
  1375. int which,mask;
  1376.  
  1377. {
  1378.  
  1379.     int value;
  1380.  
  1381.     
  1382.  
  1383.     value=tree[which].ob_state;
  1384.  
  1385.     tree[which].ob_state=value|mask;
  1386.  
  1387. }
  1388.  
  1389.  
  1390.  
  1391. /*************************************************************************/
  1392.  
  1393.  
  1394.  
  1395. /* Clears bit(s) in ob_state of object in specified tree  */
  1396.  
  1397.  
  1398.  
  1399. clear_obj(tree,which,mask)
  1400.  
  1401. OBJECT *tree;
  1402.  
  1403. int which,mask;
  1404.  
  1405. {
  1406.  
  1407.     int value;
  1408.  
  1409.     
  1410.  
  1411.     value=tree[which].ob_state;
  1412.  
  1413.     tree[which].ob_state=value&mask;
  1414.  
  1415. }
  1416.  
  1417.  
  1418.  
  1419. /*************************************************************************/
  1420.  
  1421.  
  1422.  
  1423. /*  This routine opens the printer box and monitors it for user input.
  1424.  
  1425.     It then calls the appropriate printout routine and returns to menu. */
  1426.  
  1427.  
  1428.  
  1429. print_data()
  1430.  
  1431. {
  1432.  
  1433. int type,style,choice,numcop;
  1434.  
  1435. char copstr[3];
  1436.  
  1437. /*  Sets up initial values for printer box buttons.    */
  1438.  
  1439.  
  1440.  
  1441.    clear_obj(prnt_addr,REGULAR,0xFFF6);
  1442.  
  1443.    clear_obj(prnt_addr,LABEL,0xFFFE);
  1444.  
  1445.    clear_obj(prnt_addr,SKINNY,0xFFFE);
  1446.  
  1447.    clear_obj(prnt_addr,COLUMN,0xFFFE);
  1448.  
  1449.    clear_obj(prnt_addr,PALL,0xFFFE);
  1450.  
  1451.    clear_obj(prnt_addr,PSOME,0xFFFE);
  1452.  
  1453.  
  1454.  
  1455. /*  Open printer box  */
  1456.  
  1457.  
  1458.  
  1459.         form_center (prnt_addr,&dial_x,&dial_y,&dial_w,&dial_h);
  1460.  
  1461.         objc_offset(prnt_addr,STYLES,&rdial_x,&rdial_y);
  1462.  
  1463.         form_dial (FMD_START,0,0,10,10,dial_x,dial_y,dial_w,dial_h);
  1464.  
  1465.         form_dial (FMD_GROW,0,0,10,10,dial_x,dial_y,dial_w,dial_h);
  1466.  
  1467.      
  1468.  
  1469.         objc_draw(prnt_addr,0,2,dial_x,dial_y,dial_w,dial_h);
  1470.  
  1471.       
  1472.  
  1473.         do
  1474.  
  1475.         {
  1476.  
  1477.            choice=form_do(prnt_addr,PRTITLE);
  1478.  
  1479.  
  1480.  
  1481.            switch (choice)
  1482.  
  1483.            {
  1484.  
  1485.             case LABEL:  /* Label selected, set flags and 
  1486.  
  1487.                                 enable both print types  */
  1488.  
  1489.                  clear_obj(prnt_addr,REGULAR,0xFFF7);
  1490.  
  1491.                 objc_draw(prnt_addr,STYLES,2,rdial_x,rdial_y,rdial_w,rdial_h);
  1492.  
  1493.                 type=1;
  1494.  
  1495.             break;
  1496.  
  1497.             
  1498.  
  1499.                 case COLUMN:  /* Column selected. set flag and disable normal
  1500.  
  1501.                                  print. (Won't fit on a page!  )  */
  1502.  
  1503.                 set_obj(prnt_addr,REGULAR,0x0008);
  1504.  
  1505.                 clear_obj(prnt_addr,REGULAR,0xFFFE);
  1506.  
  1507.                 set_obj(prnt_addr,SKINNY,0x0001);
  1508.  
  1509.                 objc_draw(prnt_addr,STYLES,2,rdial_x,rdial_y,rdial_w,rdial_h);
  1510.  
  1511.                 type=0;
  1512.  
  1513.                 break;
  1514.  
  1515.                 
  1516.  
  1517.                 case REGULAR: /* Selects normal printing..  */
  1518.  
  1519.                 style=1;
  1520.  
  1521.                 break;
  1522.  
  1523.                 
  1524.  
  1525.                 case SKINNY:  /* Selects condensed printing  */
  1526.  
  1527.                 style=0;
  1528.  
  1529.                 break;
  1530.  
  1531.          
  1532.  
  1533.                 case PALL:   /*  Prints all records          */
  1534.  
  1535.                 selprt=FALSE;
  1536.  
  1537.                 break;
  1538.  
  1539.  
  1540.  
  1541.                 case PSOME:  /* Prints only records marked by last search  */
  1542.  
  1543.                 selprt=TRUE;
  1544.  
  1545.                 break;
  1546.  
  1547.  
  1548.  
  1549.                 case PRINTIT: /*  Prints out records      */
  1550.  
  1551.                 find_str(prnt_addr,COPIES,copstr);
  1552.  
  1553.                 numcop=atoi(copstr);
  1554.  
  1555.                 find_str(prnt_addr,PRTITLE,title);
  1556.  
  1557.                 if(type) print_label(style,title,numcop);
  1558.  
  1559.                 else print_column(title,numcop);
  1560.  
  1561.                 break;
  1562.  
  1563.            } 
  1564.  
  1565.         }   
  1566.  
  1567.         while(choice!=CANCEL & choice !=PRINTIT);
  1568.  
  1569.         
  1570.  
  1571. /*  Close box and exit  */
  1572.  
  1573.  
  1574.  
  1575.         form_dial (FMD_SHRINK,0,0,10,10,dial_x,dial_y,dial_w,dial_h);
  1576.  
  1577.         form_dial (FMD_FINISH,0,0,10,10,dial_x,dial_y,dial_w,dial_h);
  1578.  
  1579. }
  1580.  
  1581.  
  1582.  
  1583. /*************************************************************************/
  1584.  
  1585.  
  1586.  
  1587. /* Prints title entered in printer box in double width  */
  1588.  
  1589.  
  1590.  
  1591. print_title(title)
  1592.  
  1593. char *title;
  1594.  
  1595. {
  1596.  
  1597.         int len,i;
  1598.  
  1599.         char spacestr[40];
  1600.  
  1601.         for(len=0;len<(40-strlen(title))>>1;spacestr[len++]=' ');
  1602.  
  1603.         spacestr[len]='\0';
  1604.  
  1605.         fprintf(prt,"%s",nrml);        
  1606.  
  1607.         fprintf(prt,"%s","\n\n");
  1608.  
  1609.         fprintf(prt,"%s",expanded);
  1610.  
  1611.  
  1612.  
  1613.         fprintf(prt,"%s%s\n\n\n",spacestr,title);
  1614.  
  1615. }
  1616.  
  1617.  
  1618.  
  1619. /*************************************************************************/
  1620.  
  1621.  
  1622.  
  1623. /*  Routine to print columnar output   */
  1624.  
  1625.  
  1626.  
  1627. print_column(title,cpys)
  1628.  
  1629. int cpys;
  1630.  
  1631. char *title;
  1632.  
  1633.  
  1634.  
  1635. {
  1636.  
  1637.         int i,j,cnt;
  1638.  
  1639.         char tempstr[40];
  1640.  
  1641.  
  1642.  
  1643.    prt=fopen("PRT:","w");
  1644.  
  1645.  
  1646.  
  1647.    for(j=0;j<cpys;j++)
  1648.  
  1649.    {
  1650.  
  1651.         print_title(title);
  1652.  
  1653.         fprintf(prt,"%s",nrml); 
  1654.  
  1655.         fprintf(prt,"%s",condensed);        
  1656.  
  1657.         fprintf(prt,"  Name                                Dues Status");
  1658.  
  1659.         fprintf(prt,"         Phone");
  1660.  
  1661.         fprintf(prt,"        Computer    Printer             Modem");
  1662.  
  1663.         fprintf(prt,"            Drives\n");
  1664.  
  1665.         fprintf(prt,"%-132.132s\n",sepr2);
  1666.  
  1667.         cnt=0;
  1668.  
  1669.         for(i=0;i<=rnum;i++)
  1670.  
  1671.         {
  1672.  
  1673.            if((selprt==TRUE & srch_flag[i]==TRUE) | selprt==FALSE)
  1674.  
  1675.            {
  1676.  
  1677.                strcpy(tempstr,(dbase + i)->lname);
  1678.  
  1679.                strcat(tempstr,", ");
  1680.  
  1681.                strcat(tempstr,(dbase + i)->fname);
  1682.  
  1683.                fprintf(prt,"%-39.35s",tempstr);
  1684.  
  1685.                fprintf(prt,"%-15.10s",(dbase + i)->status);
  1686.  
  1687.                fprintf(prt,"%-18.14s",(dbase + i)->phone);
  1688.  
  1689.                fprintf(prt,"%-10.6s",(dbase + i)->comp);
  1690.  
  1691.                fprintf(prt,"%-19.15s",(dbase + i)->prnt);
  1692.  
  1693.                fprintf(prt,"%-19.15s",(dbase + i)->modem);
  1694.  
  1695.                fprintf(prt,"%-11.11s\n",(dbase + i)->drive);
  1696.  
  1697.                cnt++;
  1698.  
  1699.             }
  1700.  
  1701.             if(cnt==50)
  1702.  
  1703.             {
  1704.  
  1705.                 putc(ffeed,prt);
  1706.  
  1707.                 cnt=0;
  1708.  
  1709.              }          
  1710.  
  1711.         }
  1712.  
  1713.         putc(ffeed,prt);
  1714.  
  1715.     }
  1716.  
  1717.     fclose(prt);
  1718.  
  1719. }                
  1720.  
  1721. /*************************************************************************/
  1722.  
  1723.  
  1724.  
  1725. /*  Routine to print label type output. Gives every part of record  */
  1726.  
  1727.  
  1728.  
  1729. print_label(style,title,cpys)
  1730.  
  1731. int style,cpys;
  1732.  
  1733. char *title;
  1734.  
  1735. {
  1736.  
  1737.     int i,j,cnt;
  1738.  
  1739.         char *tempstr[40];
  1740.  
  1741.  
  1742.  
  1743.    prt=fopen("PRT:","w");
  1744.  
  1745.    for(j=0;j<cpys;j++)
  1746.  
  1747.    {
  1748.  
  1749.         print_title(title);
  1750.  
  1751.  
  1752.  
  1753.         fprintf(prt,"%s",nrml); 
  1754.  
  1755.         if(!style)
  1756.  
  1757.           fprintf(prt,"%s",condensed);        
  1758.  
  1759.  
  1760.  
  1761.         cnt=0; 
  1762.  
  1763.         for(i=0;i<=rnum;i++)
  1764.  
  1765.         {
  1766.  
  1767.           if((selprt==TRUE & srch_flag[i]==TRUE) | selprt==FALSE)
  1768.  
  1769.           {
  1770.  
  1771.               strcpy(tempstr,(dbase + i)->lname);
  1772.  
  1773.               strcat(tempstr,", ");
  1774.  
  1775.               strcat(tempstr,(dbase + i)->fname);
  1776.  
  1777.               fprintf(prt,"%-50.35s%-10.10s\n",tempstr,(dbase + i)->status);
  1778.  
  1779.               fprintf(prt,"%s, %s, ",(dbase + i)->addr,(dbase + i)->city);
  1780.  
  1781.               fprintf(prt,"%-2.2s, %-5.5s\n",(dbase + i)->state,(dbase + i)->zip);
  1782.  
  1783.               fprintf(prt,"%-14.14s\n",(dbase + i)->phone);
  1784.  
  1785.               fprintf(prt,"Computer: %-6.6s     Drive(s): %-11.11s   Modem: %-15.15s\n",
  1786.  
  1787.                (dbase + i)->comp,(dbase + i)->drive,(dbase + i)->modem);
  1788.  
  1789.               fprintf(prt,"Printer: %-20.20s Other: %-25.25s\n",(dbase + i)->prnt,(dbase + i)->other);
  1790.  
  1791.               fprintf(prt,"Interests: %-25.25s%-25.25s\n",(dbase + i)->intr1,(dbase + i)->intr2);
  1792.  
  1793.               fprintf(prt,"%-79.79s\n",sepr2);
  1794.  
  1795.               cnt++;            
  1796.  
  1797.           }  
  1798.  
  1799.           if(cnt==8)
  1800.  
  1801.           {
  1802.  
  1803.              putc(ffeed,prt);
  1804.  
  1805.              cnt=0;
  1806.  
  1807.           } 
  1808.  
  1809.         }
  1810.  
  1811.         putc(ffeed,prt);
  1812.  
  1813.    } 
  1814.  
  1815.    fclose(prt);
  1816.  
  1817.  
  1818.  
  1819. }            
  1820.  
  1821. /*************************************************************************/
  1822.  
  1823.  
  1824.  
  1825. /*  This routine sorts all records by last name. It uses the bubble sort  */
  1826.  
  1827.  
  1828.  
  1829. do_sort()
  1830.  
  1831. {
  1832.  
  1833.   int i,chkflg;
  1834.  
  1835.  
  1836.  
  1837.   do
  1838.  
  1839.   {
  1840.  
  1841.       chkflg=0;
  1842.  
  1843.       for(i=0;i<rnum;i++)
  1844.  
  1845.       {
  1846.  
  1847.          if(strcmp((dbase + i + 1)->lname,(dbase + i)->lname)<0)
  1848.  
  1849.          {
  1850.  
  1851.              do_swap(i);
  1852.  
  1853.              chkflg=1;
  1854.  
  1855.          }
  1856.  
  1857.       }
  1858.  
  1859.   }
  1860.  
  1861.   while (chkflg==1);
  1862.  
  1863. }
  1864.  
  1865.  
  1866.  
  1867. /*************************************************************************/
  1868.  
  1869.  
  1870.  
  1871. /*  Swaps places with two adjacent records. Used by above routine  */
  1872.  
  1873.  
  1874.  
  1875. do_swap(which)
  1876.  
  1877. int which;
  1878.  
  1879.  
  1880.  
  1881. {
  1882.  
  1883.   int i,cnt;
  1884.  
  1885.   char temp;
  1886.  
  1887.  
  1888.  
  1889.   for(i=0;i<sizeof(struct RECORD);i++)
  1890.  
  1891.   {
  1892.  
  1893.      temp=(dbase + which)->lname[i];
  1894.  
  1895.      (dbase + which)->lname[i]=(dbase + which+1)->lname[i];
  1896.  
  1897.      (dbase + which+1)->lname[i]=temp;
  1898.  
  1899.   }
  1900.  
  1901. }  
  1902.  
  1903. /*************************************************************************/
  1904.  
  1905.  
  1906.  
  1907. /*  This routine searches selected fields for matching records      */
  1908.  
  1909.  
  1910.  
  1911. do_search()
  1912.  
  1913. {
  1914.  
  1915.    int choice,i,fndany;
  1916.  
  1917.    char string[30],intrsts[60];
  1918.  
  1919.    
  1920.  
  1921.   form_center(srch_addr,&dial_x,&dial_y,&dial_w,&dial_h);
  1922.  
  1923.   form_dial(FMD_START,0,0,10,10,dial_x,dial_y,dial_w,dial_h);
  1924.  
  1925.   form_dial(FMD_GROW,0,0,10,10,dial_x,dial_y,dial_w,dial_h);
  1926.  
  1927.   objc_draw(srch_addr,0,2,dial_x,dial_y,dial_w,dial_h);  
  1928.  
  1929.  
  1930.  
  1931.   choice=form_do(srch_addr,SLNAME);
  1932.  
  1933.   
  1934.  
  1935.   if(choice==SSEARCH)
  1936.  
  1937.   {
  1938.  
  1939.       for(i=0;i<=rnum;srch_flag[i++]=TRUE);
  1940.  
  1941.  
  1942.  
  1943. /*  Searches last name           */
  1944.  
  1945.  
  1946.  
  1947.         find_str(srch_addr,SLNAME,string);
  1948.  
  1949.         if(string[0]!='@' & strlen(string)>0)  
  1950.  
  1951.         {  
  1952.  
  1953.            for(i=0;i<=rnum;i++)
  1954.  
  1955.            {
  1956.  
  1957.                if(srch_flag[i])
  1958.  
  1959.                {
  1960.  
  1961.                   findit((dbase+i)->lname,string,i);
  1962.  
  1963.                }
  1964.  
  1965.            }
  1966.  
  1967.         }
  1968.  
  1969. /*  Searches first name           */
  1970.  
  1971.  
  1972.  
  1973.         find_str(srch_addr,SFNAME,string);
  1974.  
  1975.         if(string[0]!='@' & strlen(string)>0)  
  1976.  
  1977.         {  
  1978.  
  1979.            for(i=0;i<=rnum;i++)
  1980.  
  1981.            {
  1982.  
  1983.                if(srch_flag[i])
  1984.  
  1985.                {
  1986.  
  1987.                   findit((dbase+i)->fname,string,i);
  1988.  
  1989.                }
  1990.  
  1991.            }
  1992.  
  1993.         }
  1994.  
  1995.         
  1996.  
  1997. /*  Searches city....       */
  1998.  
  1999.  
  2000.  
  2001.         find_str(srch_addr,SCITY,string);
  2002.  
  2003.         if(string[0]!='@' & strlen(string)>0)  
  2004.  
  2005.         {  
  2006.  
  2007.            for(i=0;i<=rnum;i++)
  2008.  
  2009.            {
  2010.  
  2011.                if(srch_flag[i])
  2012.  
  2013.                {
  2014.  
  2015.                   findit((dbase+i)->city,string,i);
  2016.  
  2017.                }
  2018.  
  2019.            }
  2020.  
  2021.         }
  2022.  
  2023.         
  2024.  
  2025. /*  Searches state     */
  2026.  
  2027.  
  2028.  
  2029.         find_str(srch_addr,SSTATE,string);
  2030.  
  2031.         if(string[0]!='@' & strlen(string)>0)  
  2032.  
  2033.         {  
  2034.  
  2035.            for(i=0;i<=rnum;i++)
  2036.  
  2037.            {
  2038.  
  2039.                if(srch_flag[i])
  2040.  
  2041.                {
  2042.  
  2043.                   findit((dbase+i)->state,string,i);
  2044.  
  2045.                }
  2046.  
  2047.             }
  2048.  
  2049.         }
  2050.  
  2051.         
  2052.  
  2053. /*   Searches   zipcode    */
  2054.  
  2055.  
  2056.  
  2057.         find_str(srch_addr,SZIP,string);
  2058.  
  2059.         if(string[0]!='@' & strlen(string)>0)  
  2060.  
  2061.         {  
  2062.  
  2063.            for(i=0;i<=rnum;i++)
  2064.  
  2065.            {
  2066.  
  2067.                if(srch_flag[i])
  2068.  
  2069.                {
  2070.  
  2071.                   findit((dbase+i)->zip,string,i);
  2072.  
  2073.                }
  2074.  
  2075.             }
  2076.  
  2077.         }
  2078.  
  2079.         
  2080.  
  2081. /*   Searches Phone numbers    */
  2082.  
  2083.  
  2084.  
  2085.         find_str(srch_addr,SPHONE,string);
  2086.  
  2087.         if(string[0]!='@' & strlen(string)>0)  
  2088.  
  2089.         {  
  2090.  
  2091.            for(i=0;i<=rnum;i++)
  2092.  
  2093.            {
  2094.  
  2095.                if(srch_flag[i])
  2096.  
  2097.                {
  2098.  
  2099.                   findit((dbase+i)->phone,string,i);
  2100.  
  2101.                }
  2102.  
  2103.             }
  2104.  
  2105.         }
  2106.  
  2107.         
  2108.  
  2109. /*  Searches Dues status      */
  2110.  
  2111.  
  2112.  
  2113.         find_str(srch_addr,SSTATUS,string);
  2114.  
  2115.         if(string[0]!='@' & strlen(string)>0)  
  2116.  
  2117.         {  
  2118.  
  2119.            for(i=0;i<=rnum;i++)
  2120.  
  2121.            {
  2122.  
  2123.                if(srch_flag[i])
  2124.  
  2125.                {
  2126.  
  2127.                   findit((dbase+i)->status,string,i);
  2128.  
  2129.                }
  2130.  
  2131.             }
  2132.  
  2133.         }
  2134.  
  2135.         
  2136.  
  2137. /*  Searches Computer type      */
  2138.  
  2139.  
  2140.  
  2141.         find_str(srch_addr,SCOMP,string);
  2142.  
  2143.         if(string[0]!='@' & strlen(string)>0)  
  2144.  
  2145.         {  
  2146.  
  2147.            for(i=0;i<=rnum;i++)
  2148.  
  2149.            {
  2150.  
  2151.                if(srch_flag[i])
  2152.  
  2153.                {
  2154.  
  2155.                   findit((dbase+i)->comp,string,i);
  2156.  
  2157.                 }
  2158.  
  2159.             }
  2160.  
  2161.         }
  2162.  
  2163.         
  2164.  
  2165. /*  Searches drive type     */
  2166.  
  2167.  
  2168.  
  2169.         find_str(srch_addr,SDRIVE,string);
  2170.  
  2171.         if(string[0]!='@' & strlen(string)>0)  
  2172.  
  2173.         {  
  2174.  
  2175.            for(i=0;i<=rnum;i++)
  2176.  
  2177.            {
  2178.  
  2179.                if(srch_flag[i])
  2180.  
  2181.                {
  2182.  
  2183.                   findit((dbase+i)->drive,string,i);
  2184.  
  2185.                 }
  2186.  
  2187.            }
  2188.  
  2189.         }
  2190.  
  2191.         
  2192.  
  2193. /*  Searches  Modem type    */
  2194.  
  2195.  
  2196.  
  2197.         find_str(srch_addr,SMODEM,string);
  2198.  
  2199.         if(string[0]!='@' & strlen(string)>0)  
  2200.  
  2201.         {  
  2202.  
  2203.            for(i=0;i<=rnum;i++)
  2204.  
  2205.            {
  2206.  
  2207.                if(srch_flag[i])
  2208.  
  2209.                {
  2210.  
  2211.                   findit((dbase+i)->modem,string,i);
  2212.  
  2213.                }
  2214.  
  2215.             }
  2216.  
  2217.         }
  2218.  
  2219.         
  2220.  
  2221. /*  Searches Printer type    */
  2222.  
  2223.  
  2224.  
  2225.         find_str(srch_addr,SPRNTR,string);
  2226.  
  2227.         if(string[0]!='@' & strlen(string)>0)  
  2228.  
  2229.         {  
  2230.  
  2231.            for(i=0;i<=rnum;i++)
  2232.  
  2233.            {
  2234.  
  2235.                if(srch_flag[i])
  2236.  
  2237.                {
  2238.  
  2239.                   findit((dbase+i)->prnt,string,i);
  2240.  
  2241.                 }
  2242.  
  2243.             }
  2244.  
  2245.         }
  2246.  
  2247.         
  2248.  
  2249. /*  Searches Other field    */
  2250.  
  2251.  
  2252.  
  2253.         find_str(srch_addr,SOTHER,string);
  2254.  
  2255.         if(string[0]!='@' & strlen(string)>0)  
  2256.  
  2257.         {  
  2258.  
  2259.            for(i=0;i<=rnum;i++)
  2260.  
  2261.            {
  2262.  
  2263.                if(srch_flag[i])
  2264.  
  2265.                {
  2266.  
  2267.                   findit((dbase+i)->other,string,i);
  2268.  
  2269.                }
  2270.  
  2271.            }
  2272.  
  2273.         }
  2274.  
  2275.         
  2276.  
  2277. /*  Searches Interests fields    */
  2278.  
  2279.  
  2280.  
  2281.  
  2282.  
  2283.         find_str(srch_addr,SINTR,string);
  2284.  
  2285.         if(string[0]!='@' & strlen(string)>0)  
  2286.  
  2287.         {  
  2288.  
  2289.            for(i=0;i<=rnum;i++)
  2290.  
  2291.            {
  2292.  
  2293.                if(srch_flag[i])
  2294.  
  2295.                {
  2296.  
  2297.                   strcpy(intrsts,(dbase+i)->intr1);
  2298.  
  2299.                   strcat(intrsts,(dbase+i)->intr2);
  2300.  
  2301.                   findit(intrsts,string,i);
  2302.  
  2303.                }
  2304.  
  2305.            }
  2306.  
  2307.         }
  2308.  
  2309.         
  2310.  
  2311.   form_dial(FMD_FINISH,0,0,10,10,dial_x,dial_y,dial_w,dial_h);
  2312.  
  2313.   
  2314.  
  2315.   fndany=FALSE;
  2316.  
  2317.   for(i=0;i<=rnum;i++)
  2318.  
  2319.   {
  2320.  
  2321.       if(srch_flag[i]==TRUE)
  2322.  
  2323.               fndany=TRUE;
  2324.  
  2325.    }
  2326.  
  2327.    if(fndany)
  2328.  
  2329.    {
  2330.  
  2331.            srchit=TRUE;
  2332.  
  2333.            do_dialog();
  2334.  
  2335.     }
  2336.  
  2337.     else {
  2338.  
  2339.            srchit=FALSE;
  2340.  
  2341.            form_alert(1,nonethere);
  2342.  
  2343.     }
  2344.  
  2345.         
  2346.  
  2347.    }
  2348.  
  2349.    else {
  2350.  
  2351.           form_dial(FMD_FINISH,0,0,10,10,dial_x,dial_y,dial_w,dial_h);
  2352.  
  2353.         }
  2354.  
  2355. }
  2356.  
  2357.  
  2358.  
  2359. /*************************************************************************/
  2360.  
  2361.  
  2362.  
  2363. findit(fieldstr,srchstr,rec)
  2364.  
  2365. char *fieldstr,*srchstr;
  2366.  
  2367. int rec;
  2368.  
  2369. {
  2370.  
  2371.    int i,found;
  2372.  
  2373.    
  2374.  
  2375.        i=0;
  2376.  
  2377.        found=0;
  2378.  
  2379.        do
  2380.  
  2381.        {
  2382.  
  2383.             if(strncmp(srchstr,(fieldstr+(i++)),strlen(srchstr))==0)
  2384.  
  2385.               found=TRUE;  
  2386.  
  2387.         }
  2388.  
  2389.         while(i<=strlen(fieldstr)-strlen(srchstr) & found==FALSE);
  2390.  
  2391.         if(found==FALSE)
  2392.  
  2393.            srch_flag[rec]=FALSE;
  2394.  
  2395. }
  2396.  
  2397.  
  2398.  
  2399. /*************************************************************************/
  2400.  
  2401.  
  2402.  
  2403. /*  This routine gives credit where credit is due....(:-)   */
  2404.  
  2405.  
  2406.  
  2407. do_kudos()
  2408.  
  2409. {
  2410.  
  2411.  
  2412.  
  2413.         form_center (kudo_addr,&dial_x,&dial_y,&dial_w,&dial_h);
  2414.  
  2415.         form_dial (FMD_START,0,0,10,10,dial_x,dial_y,dial_w,dial_h);
  2416.  
  2417.      
  2418.  
  2419.         objc_draw(kudo_addr,0,2,dial_x,dial_y,dial_w,dial_h);
  2420.  
  2421.  
  2422.  
  2423.         form_do(kudo_addr,0);
  2424.  
  2425.  
  2426.  
  2427.         form_dial (FMD_SHRINK,0,0,10,10,dial_x,dial_y,dial_w,dial_h);
  2428.  
  2429.         form_dial (FMD_FINISH,0,0,10,10,dial_x,dial_y,dial_w,dial_h);
  2430.  
  2431. }
  2432.  
  2433.  
  2434.  
  2435. /*************************************************************************/
  2436.  
  2437.  
  2438.  
  2439. do_next(temp)
  2440.  
  2441. int temp;
  2442.  
  2443.  
  2444.  
  2445. {
  2446.  
  2447.    if(srchit)
  2448.  
  2449.    {
  2450.  
  2451.         while(++temp<=rnum & srch_flag[temp]!=TRUE);
  2452.  
  2453.         if(temp>rnum)
  2454.  
  2455.            return(-1);
  2456.  
  2457.         else
  2458.  
  2459.            return(temp);
  2460.  
  2461.    }
  2462.  
  2463.    else
  2464.  
  2465.    {
  2466.  
  2467.         ++temp;
  2468.  
  2469.         if(temp>rnum)
  2470.  
  2471.           temp=rnum;
  2472.  
  2473.         return(temp);
  2474.  
  2475.    }
  2476.  
  2477. }
  2478.  
  2479.  
  2480.  
  2481. /*************************************************************************/
  2482.  
  2483.  
  2484.  
  2485. do_prev(temp)
  2486.  
  2487. int temp;
  2488.  
  2489.  
  2490.  
  2491. {
  2492.  
  2493.    if(srchit)
  2494.  
  2495.    {
  2496.  
  2497.         while(--temp>=0 & srch_flag[temp]!=TRUE);
  2498.  
  2499.         if(temp<0)
  2500.  
  2501.            return(-1);
  2502.  
  2503.         else
  2504.  
  2505.            return(temp);
  2506.  
  2507.    }
  2508.  
  2509.    else
  2510.  
  2511.    {
  2512.  
  2513.         --temp;
  2514.  
  2515.         if(temp<0)
  2516.  
  2517.           temp=0;
  2518.  
  2519.         return(temp);
  2520.  
  2521.    }
  2522.  
  2523. }
  2524.  
  2525.  
  2526.  
  2527. /*************************************************************************/
  2528.  
  2529.  
  2530.  
  2531. do_start()
  2532.  
  2533.  
  2534.  
  2535. {
  2536.  
  2537.  int temp;
  2538.  
  2539.  
  2540.  
  2541.   temp=0;
  2542.  
  2543.   if(srchit)
  2544.  
  2545.   {
  2546.  
  2547.       while(srch_flag[temp++]!=TRUE);
  2548.  
  2549.       temp--;   
  2550.  
  2551.   }
  2552.  
  2553.   return(temp);
  2554.  
  2555. }
  2556.  
  2557.  
  2558.  
  2559. /*************************************************************************/
  2560.  
  2561.  
  2562.  
  2563. do_end()
  2564.  
  2565.  
  2566.  
  2567. {
  2568.  
  2569.  int temp;
  2570.  
  2571.  
  2572.  
  2573.   temp=rnum;
  2574.  
  2575.   if(srchit)
  2576.  
  2577.   {
  2578.  
  2579.       while(srch_flag[temp--]!=TRUE);
  2580.  
  2581.       temp++;
  2582.  
  2583.   }
  2584.  
  2585.   return(temp);
  2586.  
  2587. }
  2588.  
  2589.  
  2590.  
  2591. /*************************************************************************/
  2592.  
  2593.  
  2594.  
  2595. clear_srch_box()
  2596.  
  2597. {
  2598.  
  2599.      wrt_str(srch_addr,SLNAME,"\0");
  2600.  
  2601.      wrt_str(srch_addr,SFNAME,"\0");
  2602.  
  2603.      wrt_str(srch_addr,SCITY,"\0");
  2604.  
  2605.      wrt_str(srch_addr,SSTATE,"\0");
  2606.  
  2607.      wrt_str(srch_addr,SZIP,"\0");
  2608.  
  2609.      wrt_str(srch_addr,SPHONE,"\0");
  2610.  
  2611.      wrt_str(srch_addr,SSTATUS,"\0");
  2612.  
  2613.      wrt_str(srch_addr,SCOMP,"\0");
  2614.  
  2615.      wrt_str(srch_addr,SDRIVE,"\0");
  2616.  
  2617.      wrt_str(srch_addr,SMODEM,"\0");
  2618.  
  2619.      wrt_str(srch_addr,SPRNTR,"\0");
  2620.  
  2621.      wrt_str(srch_addr,SOTHER,"\0");
  2622.  
  2623.      wrt_str(srch_addr,SINTR,"\0");
  2624.  
  2625.  }
  2626.  
  2627.  
  2628.  
  2629. /*************************************************************************/
  2630.  
  2631.  
  2632.  
  2633.